﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using RobotGerchik.Config;
using RobotGerchik.DataClass.BaseTransaqCalss;
using RobotGerchik.DataClass.Gerchik;
using System.Xml.Linq;
using RobotGerchik.DataClass;

namespace RobotGerchik
{

    public delegate void ShowMassege(string message);
    /// <summary>
    /// Логика основного алгоритма робота
    /// </summary>
    class LogikGerchikRobot
    {
        private Data data;
        private MainWindow mainWindow;
        int accuraccy;
        readonly ShowMassege method;
        private static int diffTime = 1000000;
        private static DateTime tmpdateTime = DateTime.Now;
        private static double prevCurOpen;

        public LogikGerchikRobot()
        { }

        public LogikGerchikRobot(Data data, MainWindow mainWindow, ShowMassege method)
        {
            this.data = data;
            this.mainWindow = mainWindow;
            this.method = method;
            if (diffTime == 1000000)
                try
                {
                    diffTime = Convert.ToInt32((XElement.Parse(mainWindow.OConn.SendCommand(data.TransaqCommand.GetServtimeDifference()))).LastAttribute.Value);
                }
                catch
                {

                }


        }

        public void Start(GechikRobotItem GrItem)
        {
            if (MainWindow.Login != "IVAN14108")
                return;

            //цена последней сделки
            GrItem.LastPrice = data.GetLastPrice(GrItem.Instrument);
            accuraccy = data.GetAccuraccy(GrItem.Instrument);
            if (diffTime == 1000000)
                return;

            TimeSpan curTime = DateTime.Now.TimeOfDay - TimeConvertor(diffTime);

            //обрабатываем заявки до начала торгов
            GrItem.CurPosition = 0; //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! не забыть поменять на 0 после проверки стопов
            if (GrItem.TradeList != null)
                if (GrItem.TradeList.Count > 0)
                {
                    GetStatusAndBalance(GrItem);
                    GetStatusAndBalanceStopLimit(GrItem);
                    foreach (var item in GrItem.TradeList)
                    {
                        if (item.OpenBalance != 0)
                            GrItem.CurPosition = GrItem.CurPosition + item.OpenBalance + item.CloseBalance + item.OrderFromStopLimitCloseQuantity;
                    }
                }

            //снятие стоп-заявок, если позиция равна нулю
            if (GrItem.CurPosition == 0 && GrItem.TradeList.Count > 0)
            {
                var StopLimitMassiv = data.GetStopOrderListAllforInstrunemtsActive(GrItem.Account, GrItem.ClientCode, GrItem.Instrument);
                if (StopLimitMassiv.Count > 0 && GrItem.TradeList.Count > 0)
                {
                    foreach (var stopItem in StopLimitMassiv)
                    {
                        if (stopItem.Transactionid == GrItem.TradeList[0].StopLimitCloseID)
                        {
                            mainWindow.OConn.SendCommand(
                                data.TransaqCommand.CancelStopOrder(GrItem.TradeList[0].StopLimitCloseID));
                            method(
                                string.Format("Снятие стоп-заявки при нулевой позиции"));
                            GrItem.TradeList.Remove(GrItem.TradeList[0]);
                            break;
                        }
                    }
                }
            }

            //Логика просчета свечей и определение возомжности входа в позицию
            foreach (var item in data.CandlesItems)
            {


                int curCandle = item.Candle.Count - 1;
                int thirdCandle = item.Candle.Count - 2;
                int secondCandle = item.Candle.Count - 3;
                int firstCandle = item.Candle.Count - 4;
                if (item.Seccode == GrItem.Instrument && MainWindow.DictionaryTimeFrame.FirstOrDefault(x => x.Value == GrItem.TimeFrame).Key == item.Period)
                    for (int i = item.Candle.Count - 2; i >= 3; i--)
                    {


                        if (prevCurOpen != item.Candle[curCandle].Open)
                        {
                            method(
                                string.Format(
                                    "Время: {6}     . Время третьей свечи {0} , Low={1}, Время второй свечи {2} , Low={3}, Время первой свечи {4} , Low={5} "
                                    , item.Candle[thirdCandle].DateTime, item.Candle[thirdCandle].Low,
                                    item.Candle[secondCandle].DateTime, item.Candle[secondCandle].Low,
                                    item.Candle[firstCandle].DateTime, item.Candle[firstCandle].Low,
                                    item.Candle[curCandle].DateTime.TimeOfDay));
                            prevCurOpen = item.Candle[curCandle].Open;

                        }

                        
                            if (item.Candle[curCandle].DateTime.Date == DateTime.Now.Date && item.Candle[i - 2].DateTime.Date == DateTime.Now.Date && item.Candle[thirdCandle].DateTime.Date == DateTime.Now.Date)
                            {
                                if (GrItem.CurrentAttempt < GrItem.AttemptAmount)
                                {
                                    #region Открытие позиции

                                    if (item.Candle[i].DateTime.TimeOfDay > GrItem.TimeStartLevel.TimeOfDay &&
                                        item.Candle[curCandle].DateTime.TimeOfDay <= GrItem.TimeStopLevel.TimeOfDay &&
                                        item.Candle[curCandle].DateTime.TimeOfDay < GrItem.TimeClosePoz.TimeOfDay &&
                                        item.Candle[firstCandle].DateTime.TimeOfDay > GrItem.TimeStartLevel.TimeOfDay)
                                    {
                                        // if (GrItem.TradeList.Count == 0)
                                        //LimitOrMarketOrderForOpenPosition(GrItem, item.Candle[curCandle].Open, item.Candle[secondCandle].Low, Cfg.Sell);
                                        //Открытие позиций
                                        if (tmpdateTime.TimeOfDay + new TimeSpan(0, 0, 10) <= DateTime.Now.TimeOfDay)

                                            if (GrItem.CurPosition == 0 && GrItem.TradeList.Count == 0)
                                            {
                                                #region Pattern #1

                                                //Условия для входа в лонг
                                                //if (item.Candle[i].Low >= item.Candle[i - 1].Low &&
                                                //    item.Candle[i].Low <= item.Candle[i - 1].Low + GrItem.ThirdBarDeviation &&
                                                //    item.Candle[i - 1].Low == item.Candle[i - 2].Low)
                                                if (item.Candle[thirdCandle].Low >= item.Candle[secondCandle].Low &&
                                                    item.Candle[thirdCandle].Low <=
                                                    item.Candle[secondCandle].Low + GrItem.ThirdBarDeviation &&
                                                    item.Candle[secondCandle].Low == item.Candle[firstCandle].Low)
                                                {
                                                    method(
                                                        string.Format(
                                                            "Условия для входа в лонг по паттерну №1. Время третьей свечи {0} , Low={1}, Время второй свечи {2} , Low={3}, Время первой свечи {4} , Low={5} "
                                                            , item.Candle[thirdCandle].DateTime,
                                                            item.Candle[thirdCandle].Low,
                                                            item.Candle[secondCandle].DateTime,
                                                            item.Candle[secondCandle].Low,
                                                            item.Candle[firstCandle].DateTime,
                                                            item.Candle[firstCandle].Low));

                                                    LimitOrMarketOrderForOpenPosition(GrItem,
                                                        item.Candle[curCandle].Open, item.Candle[secondCandle].Low,
                                                        Cfg.Buy);
                                                    return;

                                                }

                                                //Условия для входа в шорт
                                                //if (item.Candle[i].High <= item.Candle[i - 1].High &&
                                                //    item.Candle[i].High >= item.Candle[i - 1].High - GrItem.ThirdBarDeviation &&
                                                //    item.Candle[i - 1].High == item.Candle[i - 2].High)
                                                if (item.Candle[thirdCandle].High <= item.Candle[secondCandle].High &&
                                                    item.Candle[thirdCandle].High >=
                                                    item.Candle[secondCandle].High - GrItem.ThirdBarDeviation &&
                                                    item.Candle[secondCandle].High == item.Candle[firstCandle].High)
                                                {
                                                    method(
                                                        string.Format(
                                                            "Условия для входа в шорт по паттерну №1. Время третьей свечи {0} , High={1}, Время второй свечи {2} , High={3}, Время первой свечи {4} , High={5} "
                                                            , item.Candle[thirdCandle].DateTime,
                                                            item.Candle[thirdCandle].High,
                                                            item.Candle[secondCandle].DateTime,
                                                            item.Candle[secondCandle].High,
                                                            item.Candle[firstCandle].DateTime,
                                                            item.Candle[firstCandle].High));

                                                    LimitOrMarketOrderForOpenPosition(GrItem,
                                                        item.Candle[curCandle].Open, item.Candle[secondCandle].High,
                                                        Cfg.Sell);
                                                    return;
                                                }

                                                #endregion

                                                #region Pattern #2

                                                #region Вариация №1 (2и3 отдельно от 1)

                                                //Условия для входа в лонг
                                                if (item.Candle[thirdCandle].Low >= item.Candle[secondCandle].Low &&
                                                    item.Candle[thirdCandle].Low <=
                                                    item.Candle[secondCandle].Low + GrItem.ThirdBarDeviation &&
                                                    item.Candle[secondCandle].Low == item.Candle[i - 2].Low)
                                                {
                                                    method(
                                                        string.Format(
                                                            "Условия для входа в лонг по паттерну №2 (2и3 low отдельно от 1). Время третьей свечи {0} , Low={1}, Время второй свечи {2} , Low={3}, Время первой свечи {4} , Low={5} "
                                                            , item.Candle[thirdCandle].DateTime,
                                                            item.Candle[thirdCandle].Low,
                                                            item.Candle[secondCandle].DateTime,
                                                            item.Candle[secondCandle].Low,
                                                            item.Candle[i - 2].DateTime, item.Candle[i - 2].Low));
                                                    LimitOrMarketOrderForOpenPosition(GrItem,
                                                        item.Candle[curCandle].Open, item.Candle[secondCandle].Low,
                                                        Cfg.Buy);
                                                    return;

                                                }

                                                //Условия для входа в шорт
                                                if (item.Candle[thirdCandle].High <=
                                                    item.Candle[secondCandle].High &&
                                                    item.Candle[thirdCandle].High >=
                                                    item.Candle[secondCandle].High - GrItem.ThirdBarDeviation &&
                                                    item.Candle[secondCandle].High == item.Candle[i - 2].High)
                                                {
                                                    method(
                                                        string.Format(
                                                            "Условия для входа в шорт по паттерну №2 (2и3 low отдельно от 1 ). Время третьей свечи {0} , High={1}, Время второй свечи {2} , High={3}, Время первой свечи {4} , High={5} "
                                                            , item.Candle[thirdCandle].DateTime,
                                                            item.Candle[thirdCandle].High,
                                                            item.Candle[secondCandle].DateTime,
                                                            item.Candle[secondCandle].High,
                                                            item.Candle[i - 2].DateTime, item.Candle[i - 2].High));
                                                    LimitOrMarketOrderForOpenPosition(GrItem,
                                                        item.Candle[curCandle].Open, item.Candle[secondCandle].High,
                                                        Cfg.Sell);
                                                    return;
                                                }

                                                #endregion

                                                #region Вариация №2 (1и2 отдельно от 3)

                                                //Условия для входа в лонг
                                                if (item.Candle[thirdCandle].Low == item.Candle[i - 1].Low &&
                                                    item.Candle[i - 1].Low == item.Candle[i - 2].Low)
                                                {
                                                    method(
                                                        string.Format(
                                                            "Условия для входа в лонг по паттерну №2 (1и2 отдельно от 3). Время третьей свечи {0} , Low={1}, Время второй свечи {2} , Low={3}, Время первой свечи {4} , Low={5} "
                                                            , item.Candle[thirdCandle].DateTime,
                                                            item.Candle[thirdCandle].Low,
                                                            item.Candle[i - 1].DateTime, item.Candle[i - 1].Low,
                                                            item.Candle[i - 2].DateTime, item.Candle[i - 2].Low));
                                                    LimitOrMarketOrderForOpenPosition(GrItem,
                                                        item.Candle[curCandle].Open, item.Candle[i - 2].Low, Cfg.Buy);
                                                    return;
                                                }

                                                //Условия для входа в шорт
                                                if (item.Candle[thirdCandle].High == item.Candle[i - 1].High &&
                                                    item.Candle[i - 1].High == item.Candle[i - 2].High)
                                                {
                                                    method(
                                                        string.Format(
                                                            "Условия для входа в шорт по паттерну №2 (1и2 отдельно от 3 ). Время третьей свечи {0} , High={1}, Время второй свечи {2} , High={3}, Время первой свечи {4} , High={5} "
                                                            , item.Candle[thirdCandle].DateTime,
                                                            item.Candle[thirdCandle].High,
                                                            item.Candle[i - 1].DateTime, item.Candle[i - 1].High,
                                                            item.Candle[i - 2].DateTime, item.Candle[i - 2].High));
                                                    LimitOrMarketOrderForOpenPosition(GrItem,
                                                        item.Candle[curCandle].Open, item.Candle[i - 2].High, Cfg.Sell);
                                                    return;
                                                }

                                                #endregion

                                                #endregion

                                                #region Pattern #3

                                                #region Вариация №1 (1 high 2 low 3 low вместе)

                                                //Условия для входа в лонг
                                                //if (item.Candle[i].Low >= item.Candle[i - 1].Low &&
                                                //    item.Candle[i].Low <= item.Candle[i - 1].Low + GrItem.ThirdBarDeviation &&
                                                //    item.Candle[i - 1].Low == item.Candle[i - 2].High)
                                                if (item.Candle[thirdCandle].Low >= item.Candle[secondCandle].Low &&
                                                    item.Candle[thirdCandle].Low <=
                                                    item.Candle[secondCandle].Low + GrItem.ThirdBarDeviation &&
                                                    item.Candle[secondCandle].Low == item.Candle[firstCandle].High)
                                                {
                                                    method(
                                                        string.Format(
                                                            "Условия для входа в лонг по паттерну №3 (1 high 2 low 3 low вместе). Время третьей свечи {0} , Low={1}, Время второй свечи {2} , Low={3}, Время первой свечи {4} , Hgih={5} "
                                                            , item.Candle[thirdCandle].DateTime,
                                                            item.Candle[thirdCandle].Low,
                                                            item.Candle[secondCandle].DateTime,
                                                            item.Candle[secondCandle].Low,
                                                            item.Candle[firstCandle].DateTime,
                                                            item.Candle[firstCandle].High));
                                                    LimitOrMarketOrderForOpenPosition(GrItem,
                                                        item.Candle[curCandle].Open, item.Candle[secondCandle].Low,
                                                        Cfg.Buy);
                                                    return;
                                                }

                                                //Условия для входа в шорт
                                                //if (item.Candle[i].High <= item.Candle[i - 1].High &&
                                                //    item.Candle[i].High >= item.Candle[i - 1].High - GrItem.ThirdBarDeviation &&
                                                //    item.Candle[i - 1].High == item.Candle[i - 2].Low)
                                                if (item.Candle[thirdCandle].High <= item.Candle[secondCandle].High &&
                                                    item.Candle[thirdCandle].High >=
                                                    item.Candle[secondCandle].High - GrItem.ThirdBarDeviation &&
                                                    item.Candle[secondCandle].High == item.Candle[firstCandle].Low)
                                                {
                                                    method(
                                                        string.Format(
                                                            "Условия для входа в шорт по паттерну №3 (1 low 2 High 3 High вместе). Время третьей свечи {0} , High={1}, Время второй свечи {2} , High={3}, Время первой свечи {4} , Low={5} "
                                                            , item.Candle[thirdCandle].DateTime,
                                                            item.Candle[thirdCandle].High,
                                                            item.Candle[secondCandle].DateTime,
                                                            item.Candle[secondCandle].High,
                                                            item.Candle[firstCandle].DateTime,
                                                            item.Candle[firstCandle].Low));
                                                    LimitOrMarketOrderForOpenPosition(GrItem,
                                                        item.Candle[curCandle].Open, item.Candle[secondCandle].High,
                                                        Cfg.Sell);
                                                    return;

                                                }

                                                #endregion

                                                #region Вариация №2 (1и2 low 3 high вместе)

                                                //Условия для входа в лонг
                                                //if (item.Candle[i].High >= item.Candle[i - 1].Low &&
                                                //    item.Candle[i].High <= item.Candle[i - 1].Low + GrItem.ThirdBarDeviation &&
                                                //    item.Candle[i - 1].Low == item.Candle[i - 2].Low)
                                                if (item.Candle[thirdCandle].High >= item.Candle[secondCandle].Low &&
                                                    item.Candle[thirdCandle].High <= item.Candle[secondCandle].Low &&
                                                    item.Candle[secondCandle].Low == item.Candle[firstCandle].Low)
                                                {
                                                    method(
                                                        string.Format(
                                                            "Условия для входа в лонг по паттерну №3 (1и2 low 3 high вместе). Время третьей свечи {0} , High={1}, Время второй свечи {2} , Low={3}, Время первой свечи {4} , Low={5} "
                                                            , item.Candle[thirdCandle].DateTime,
                                                            item.Candle[thirdCandle].High,
                                                            item.Candle[secondCandle].DateTime,
                                                            item.Candle[secondCandle].Low,
                                                            item.Candle[firstCandle].DateTime,
                                                            item.Candle[firstCandle].Low));
                                                    LimitOrMarketOrderForOpenPosition(GrItem,
                                                        item.Candle[curCandle].Open, item.Candle[secondCandle].Low,
                                                        Cfg.Buy);
                                                    return;
                                                }

                                                //Условия для входа в шорт
                                                if (item.Candle[thirdCandle].Low <= item.Candle[secondCandle].High &&
                                                    item.Candle[thirdCandle].Low >= item.Candle[secondCandle].High &&
                                                    item.Candle[secondCandle].High == item.Candle[firstCandle].High)
                                                {
                                                    method(
                                                        string.Format(
                                                            "Условия для входа в шорт по паттерну №3 (1 High 2 High 3 Low вместе). Время третьей свечи {0} , Low={1}, Время второй свечи {2} , High={3}, Время первой свечи {4} , High={5} "
                                                            , item.Candle[thirdCandle].DateTime,
                                                            item.Candle[thirdCandle].Low,
                                                            item.Candle[secondCandle].DateTime,
                                                            item.Candle[secondCandle].High,
                                                            item.Candle[firstCandle].DateTime,
                                                            item.Candle[firstCandle].High));
                                                    LimitOrMarketOrderForOpenPosition(GrItem,
                                                        item.Candle[curCandle].Open, item.Candle[secondCandle].High,
                                                        Cfg.Sell);
                                                    return;
                                                }

                                                #endregion

                                                #region Вариация №3 (2и3 low отдельно от 1 high)

                                                //Условия для входа в лонг
                                                if (item.Candle[thirdCandle].Low >= item.Candle[secondCandle].Low &&
                                                    item.Candle[thirdCandle].Low <=
                                                    item.Candle[secondCandle].Low + GrItem.ThirdBarDeviation &&
                                                    item.Candle[secondCandle].Low == item.Candle[i - 2].High)
                                                {
                                                    method(
                                                        string.Format(
                                                            "Условия для входа в лонг по паттерну №3 (2и3 low отдельно от 1 high). Время третьей свечи {0} , Low={1}, Время второй свечи {2} , Low={3}, Время первой свечи {4} , Hgih={5} "
                                                            , item.Candle[thirdCandle].DateTime,
                                                            item.Candle[thirdCandle].Low,
                                                            item.Candle[secondCandle].DateTime,
                                                            item.Candle[secondCandle].Low,
                                                            item.Candle[i - 2].DateTime, item.Candle[i - 2].High));
                                                    LimitOrMarketOrderForOpenPosition(GrItem,
                                                        item.Candle[curCandle].Open, item.Candle[secondCandle].Low,
                                                        Cfg.Buy);
                                                    return;

                                                }

                                                //Условия для входа в шорт
                                                if (item.Candle[thirdCandle].High <=
                                                    item.Candle[secondCandle].High &&
                                                    item.Candle[thirdCandle].High >=
                                                    item.Candle[secondCandle].High - GrItem.ThirdBarDeviation &&
                                                    item.Candle[secondCandle].High == item.Candle[i - 2].Low)
                                                {
                                                    method(
                                                        string.Format(
                                                            "Условия для входа в шорт по паттерну №3 (2и3 High отдельно от 1 Low). Время третьей свечи {0} , High={1}, Время второй свечи {2} , High={3}, Время первой свечи {4} , Low={5} "
                                                            , item.Candle[thirdCandle].DateTime,
                                                            item.Candle[thirdCandle].High,
                                                            item.Candle[secondCandle].DateTime,
                                                            item.Candle[secondCandle].High,
                                                            item.Candle[i - 2].DateTime, item.Candle[i - 2].Low));
                                                    LimitOrMarketOrderForOpenPosition(GrItem,
                                                        item.Candle[curCandle].Open, item.Candle[secondCandle].High,
                                                        Cfg.Sell);
                                                    return;
                                                }

                                                #endregion

                                                #endregion
                                            }
                                    }

                                    #endregion
                                }
                                //Закрытие позиции в конце дня
                                if (GrItem.TimeClosePoz.TimeOfDay <= item.Candle[curCandle].DateTime.TimeOfDay && GrItem.CurPosition != 0) //&& GrItem.TradeList[0].CloseStatusOrder == null нужно думать как фильтровать, возможно через булевую переменную
                                {
                                    if (GrItem.TradeList[0].CloseStatusOrder == Cfg.Active && GrItem.CloseEndDay == false)
                                    {
                                        mainWindow.OConn.SendCommand(
                                            data.TransaqCommand.CancelOrder(GrItem.TradeList[0].CloseID));
                                        method(
                                            string.Format("Закрытие по времени закрытии. Снятие ордера на закрытие позции"));
                                    }
                                    GrItem.CloseEndDay = true;
                                    if (GrItem.CloseEndDay == true && GrItem.TradeList[0].CloseStatusOrder == Cfg.Cancel)
                                    {
                                        CloseMarketPosition(GrItem);
                                        GrItem.TradeList[0].CloseStatusOrder = Cfg.Unknown;
                                        GrItem.TradeList[0].CloseDate = DateTime.Now;
                                        method(
                                         string.Format("Закрытие по времени закрытии. Закрытие позиции по рынку"));
                                    }
                                }


                            }
                    }


            }

            //Выставление стопов и профитон на закрытие позиции
            //if (curTime > GrItem.TimeStartLevel.TimeOfDay && curTime <= GrItem.TimeStopLevel.TimeOfDay)
            if (GrItem.CurPosition != 0 && GrItem.TradeList.Count > 0)
            {
                //снятие лимитной заявки на открытие позиции, при уходе ценаы на заданную величину
                if (GrItem.LastPrice >= GrItem.LevelPrice + GrItem.KillOrderPoint && GrItem.TradeList[0].OpenOperation == Cfg.Buy && GrItem.TradeList[0].OpenStatusOrder == Cfg.Active)
                {
                    mainWindow.OConn.SendCommand(
                        data.TransaqCommand.CancelOrder(GrItem.TradeList[0].OpenID));
                    method(
                        string.Format("Снятие лимитной заявки на открытие при уходе цена на заданную величину от уровня"));
                }
                if (GrItem.LastPrice <= GrItem.LevelPrice - GrItem.KillOrderPoint && GrItem.TradeList[0].OpenOperation == Cfg.Sell && GrItem.TradeList[0].OpenStatusOrder == Cfg.Active)
                {
                    mainWindow.OConn.SendCommand(
                        data.TransaqCommand.CancelOrder(GrItem.TradeList[0].OpenID));
                    method(
                        string.Format("Снятие лимитной заявки на открытие при уходе цена на заданную величину от уровня"));
                }

                //#region Заявки на профит
                //if (GrItem.TradeList[0].OpenOperation == Cfg.Buy)
                //{
                //    //закрытие по профиту, лимитная заявка по рынку
                //    if (GrItem.LastPrice >= GrItem.LevelPrice + GrItem.Profit && GrItem.TradeList[0].CloseStatusOrder == null)
                //    {
                //        CloseMarketPosition(GrItem);
                //        GrItem.TradeList[0].CloseStatusOrder = Cfg.Unknown;
                //        method(
                //            string.Format("Закрытие по профиту. Закрытие позиции по рынку"));
                //    }
                //}

                //if (GrItem.TradeList[0].OpenOperation == Cfg.Sell)
                //{
                //    //закрытие по профиту
                //    if (GrItem.LastPrice <= GrItem.LevelPrice - GrItem.Profit && GrItem.TradeList[0].CloseStatusOrder == null)
                //    {
                //        CloseMarketPosition(GrItem);
                //        GrItem.TradeList[0].CloseStatusOrder = Cfg.Unknown;
                //        method(
                //         string.Format("Закрытие по профиту. Закрытие позиции по рынку"));
                //    }
                //}
                //#endregion

                #region Безубыток, прверяем можем ли мы переносить его
                if (GrItem.TradeList[0].OpenOperation == Cfg.Buy)
                    if (GrItem.LastPrice >= GrItem.LevelPrice + GrItem.Breakeven)
                        GrItem.BreakevenFlag = true;

                if (GrItem.TradeList[0].OpenOperation == Cfg.Sell)
                    if (GrItem.LastPrice <= GrItem.LevelPrice - GrItem.Breakeven)
                        GrItem.BreakevenFlag = true;

                #endregion


                if (GrItem.TradeList[0].StopLimitCloseStatusOrder == null || (GrItem.TradeList[0].StopLimitCloseStatusOrder == Cfg.Cancel && GrItem.BreakevenFlag == true))
                {
                    SendStopOrder(GrItem);
                }
            }
        }

        /// <summary>
        /// Отправка транзакции на зактрытие позиции
        /// </summary>
        /// <param name="grItem"></param>
        public void CloseMarketPosition(GechikRobotItem grItem)
        {
            grItem.TradeList[0].CloseID =
                    Convert.ToInt32(
                        (XElement.Parse(
                            mainWindow.OConn.SendCommand(data.TransaqCommand.NewOrderBoardSeccode(true, false, 0,
                                data.GetBoard(grItem.Instrument), grItem.Instrument, grItem.ClientCode,
                                Math.Abs(grItem.Quantity), 0, grItem.Quantity > 0 ? 'B' : 'S', "")))).LastAttribute.Value);
            grItem.TradeList[0].CloseStatusOrder = Cfg.Unknown;
        }


        #region Работа со стоп-заявками
        /// <summary>
        /// Отрпавка транзакций по стоп-лимит
        /// </summary>
        /// <param name="grItem"></param>
        public void SendStopOrder(GechikRobotItem grItem)
        {
            if (grItem.TradeList[0].OpenOperation == Cfg.Buy)
            {
                grItem.TradeList[0].StopLimitCloseID =
                    Convert.ToInt32(
                        (XElement.Parse(
                            mainWindow.OConn.SendCommand(data.TransaqCommand.NewStopOrderBoardSeccode(true,
                                true, 0, data.GetBoard(grItem.Instrument), grItem.Instrument,
                                grItem.ClientCode,
                                Math.Abs(grItem.Quantity), grItem.TradeList[0].OpenOperation == Cfg.Sell ? 'B' : 'S', "",
                                GetStopPrice(grItem), 0, GetTakeProfit(grItem), 0, 0)))).LastAttribute.Value);
                grItem.TradeList[0].StopLimitCloseStatusOrder = Cfg.Unknown;
                grItem.TradeList[0].StopLimitClosePrice = GetStopPrice(grItem);
                method(
                    string.Format("Выставление стоп-заявки для позиции лонг. "));
            }
            if (grItem.TradeList[0].OpenOperation == Cfg.Sell)
            {

                grItem.TradeList[0].StopLimitCloseID =
                    Convert.ToInt32(
                        (XElement.Parse(
                            mainWindow.OConn.SendCommand(data.TransaqCommand.NewStopOrderBoardSeccode(true,
                                true, 0, data.GetBoard(grItem.Instrument), grItem.Instrument,
                                grItem.ClientCode,
                                Math.Abs(grItem.Quantity), grItem.TradeList[0].OpenOperation == Cfg.Sell ? 'B' : 'S', "",
                                GetStopPrice(grItem), 0, GetTakeProfit(grItem), 0, 0)))).LastAttribute.Value);
                grItem.TradeList[0].StopLimitCloseStatusOrder = Cfg.Unknown;
                grItem.TradeList[0].StopLimitClosePrice = GetStopPrice(grItem);
                method(
                    string.Format("Выставление стоп-заявки для позиции шорт. "));
            }
        }

        /// <summary>
        /// Определение стоп-цены для стоп-заявки
        /// </summary>
        /// <param name="grItem"></param>
        /// <returns></returns>
        public double GetStopPrice(GechikRobotItem grItem)
        {
            if (grItem.TradeList[0].OpenOperation == Cfg.Buy)
            {
                if (grItem.BreakevenFlag == false)
                    return Math.Round(grItem.LevelPrice - grItem.StopLimiOtstup, accuraccy);
                else
                    return Math.Round(grItem.LevelPrice, accuraccy);
            }
            if (grItem.TradeList[0].OpenOperation == Cfg.Sell)
            {
                if (grItem.BreakevenFlag == false)
                    return Math.Round(grItem.LevelPrice + grItem.StopLimiOtstup, accuraccy);
                else
                    return Math.Round(grItem.LevelPrice, accuraccy);
            }

            return 0;
        }

        /// <summary>
        /// Определение стоп-цены для стоп-заявки
        /// </summary>
        /// <param name="grItem"></param>
        /// <returns></returns>
        public double GetTakeProfit(GechikRobotItem grItem)
        {
            if (grItem.TradeList[0].OpenOperation == Cfg.Buy)
            {
                return Math.Round(grItem.LevelPrice + grItem.Profit, accuraccy);
            }
            if (grItem.TradeList[0].OpenOperation == Cfg.Sell)
            {
                return Math.Round(grItem.LevelPrice - grItem.Profit, accuraccy);
            }

            return 0;
        }
        #endregion

        #region Работа с заявками
        /// <summary>
        /// Выбор опреации рыночная или лимитная, в зависимости от отркытия четвертой свечи
        /// </summary>
        /// <param name="grItem"></param>
        /// <param name="priceFourCandle"></param>
        /// <param name="priceLevel"></param>
        private void LimitOrMarketOrderForOpenPosition(GechikRobotItem grItem, double priceFourCandle, double priceLevel, string oper)
        {
            grItem.LevelPrice = priceLevel;
            grItem.CurrentAttempt = grItem.CurrentAttempt + 1;
            if (oper == Cfg.Buy)
            {
                if (priceFourCandle > Math.Round(priceLevel + grItem.MaxExcess, accuraccy))
                {
                    method(
                        string.Format("Открытие лимитным ордером. Цена текущей свечи: " + priceFourCandle.ToString() + " Уровень + превышение = " + (Math.Round(priceLevel + grItem.MaxExcess, accuraccy)).ToString()));
                    OpenOrderNew(grItem, oper, Math.Round(priceLevel + grItem.MaxExcess, accuraccy), false);

                }
                else
                {
                    method(
string.Format("Открытие рыночным ордером. Цена текущей свечи: " + priceFourCandle.ToString() + " Уровень + превышение = " + (Math.Round(priceLevel + grItem.MaxExcess, accuraccy)).ToString()));
                    OpenOrderNew(grItem, oper, Math.Round(priceLevel + grItem.MaxExcess, accuraccy), true);

                }
            }
            else
            {
                if (priceFourCandle < Math.Round(priceLevel - grItem.MaxExcess, accuraccy))
                {
                    method(
string.Format("Открытие лимитным ордером. Цена текущей свечи: " + priceFourCandle.ToString() + " Уровень - превышение = " + (Math.Round(priceLevel - grItem.MaxExcess, accuraccy)).ToString()));
                    OpenOrderNew(grItem, oper, Math.Round(priceLevel - grItem.MaxExcess, accuraccy), false);

                }
                else
                {
                    method(
string.Format("Открытие рыночным ордером. Цена текущей свечи: " + priceFourCandle.ToString() + " Уровень - превышение = " + (Math.Round(priceLevel - grItem.MaxExcess, accuraccy)).ToString()));
                    OpenOrderNew(grItem, oper, Math.Round(priceLevel - grItem.MaxExcess, accuraccy), true);

                }
            }
        }


        /// <summary>
        /// Добавление новой заявки на открытие
        /// </summary>
        /// <param name="item"></param>
        /// <param name="oper"></param>
        /// <param name="price"></param>
        /// <param name="marketOper">тип заявки рыночная или лимитная</param>
        private void OpenOrderNew(GechikRobotItem item, string oper, double price, bool marketOper)
        {

            if (item.TradeList == null)
                item.TradeList = new System.Collections.ObjectModel.ObservableCollection<TradesOpen>();

            if (oper == Cfg.Buy)
                AddOrderOpenTotradeList(item, price, oper == "Купля" ? 'B' : 'S', marketOper);

            if (oper == Cfg.Sell)
                AddOrderOpenTotradeList(item, price, oper == "Купля" ? 'B' : 'S', marketOper);
        }

        /// <summary>
        /// выставляем заявкку на откртыие позиции и записываем в лист
        /// </summary>
        /// <param name="item"></param>
        /// <param name="priceOpen"></param>
        /// <param name="oper"></param>
        /// <param name="marketOper"></param>
        private void AddOrderOpenTotradeList(GechikRobotItem item, double priceOpen, char oper, bool marketOper)
        {
            TradesOpen tradesOpen = new TradesOpen();
            tradesOpen.OpenDate = DateTime.Now;
            try
            {

                // var dfdf = data.TransaqCommand.NewOrderBoardSeccode(marketOper, true, 0, data.GetBoard(item.Instrument), item.Instrument, item.ClientCode, item.Quantity, priceOpen, oper, "");
                // var dfdfff = mainWindow.OConn.SendCommand(dfdf);
                tradesOpen.OpenID =
                     Convert.ToInt32(
                         (XElement.Parse(
                             mainWindow.OConn.SendCommand(data.TransaqCommand.NewOrderBoardSeccode(marketOper, true, 0,
                                 data.GetBoard(item.Instrument), item.Instrument, item.ClientCode, item.Quantity,
                                 priceOpen, oper, "")))).LastAttribute.Value);

                if (oper == 'B')
                {
                    tradesOpen.OpenOperation = "Купля";
                    tradesOpen.OpenPriceOrder = priceOpen;
                    tradesOpen.OpenQuantity = item.Quantity;
                }
                else
                {
                    tradesOpen.OpenOperation = "Продажа";
                    tradesOpen.OpenPriceOrder = priceOpen;
                    tradesOpen.OpenQuantity = -item.Quantity;
                }

                tradesOpen.OpenStatusOrder = Cfg.Unknown;
                item.TradeList.Add(tradesOpen);
            }
            catch
            {
            }
        }
        #endregion



        /// <summary>
        /// Преобразование секунд в текущее время
        /// </summary>
        /// <param name="seconds"></param>
        /// <returns></returns>
        private TimeSpan TimeConvertor(int seconds)
        {
            int hour = seconds / 60 / 60;
            int minutes = (seconds - 60 * 60 * hour) / 60;
            int second = seconds - 60 * 60 * hour - minutes * 60;
            TimeSpan result = new TimeSpan(hour, minutes, second);

            return result;
        }

        /// <summary>
        /// блок проверки заявок на изменение статуса и баланса
        /// </summary>
        /// <param name="ld"></param>
        public void GetStatusAndBalance(GechikRobotItem ld)
        {
            try
            {
                var orderMassiv = data.GetOrderListAllforInstrunemts(ld.Account, ld.ClientCode, ld.Instrument);

                for (int i = 0; i < ld.TradeList.Count; i++)
                {
                    if (ld.TradeList.Count == 0)
                        break;

                    #region Проверка объема
                    foreach (var item2 in orderMassiv)
                    {
                        //проверка статусов на изменение заявок на открытие пока балансе не равен выставленному числу
                        if (item2.Transactionid == ld.TradeList[i].OpenID && ld.TradeList[i].OpenBalance != Math.Abs(ld.TradeList[i].OpenQuantity))
                        {
                            ld.TradeList[i].OpenNumberOrder = item2.Orderno;
                            ld.TradeList[i].OpenStatusOrder = item2.Status;
                            if (Math.Abs(ld.TradeList[i].OpenQuantity) == item2.Quantity)
                                ld.TradeList[i].OpenBalance = item2.Quantity - item2.Balance;
                            else
                            {
                                //если заявка снята либо в конце сеесии либо врунчую и надо выставляться на меньший объем
                                if (ld.TradeList[i].OpenQuantity > ld.TradeList[i].OpenBalance + item2.Balance)
                                    ld.TradeList[i].OpenBalance = ld.TradeList[i].OpenQuantity - item2.Balance;
                                if (ld.TradeList[i].OpenQuantity == ld.TradeList[i].OpenBalance + item2.Balance && item2.Balance == 0)
                                    ld.TradeList[i].OpenBalance = ld.TradeList[i].OpenQuantity;
                            }
                        }

                        //проверка статусов на изменение заявок на закрытие позиции пока балансе не равен выставленному числу
                        if (ld.TradeList[i].OpenBalance == ld.TradeList[i].OpenQuantity)
                            if (item2.Transactionid == ld.TradeList[i].CloseID && ld.TradeList[i].CloseBalance != ld.TradeList[i].CloseQuantity)
                            {
                                ld.TradeList[i].CloseNumberOrder = item2.Orderno;
                                ld.TradeList[i].CloseStatusOrder = item2.Status;
                                if (ld.TradeList[i].CloseQuantity == item2.Quantity)
                                    ld.TradeList[i].CloseBalance = item2.Quantity - item2.Balance;
                                else
                                {
                                    //если заявка снята либо в конце сеесии либо врунчую и надо выставляться на меньший объем
                                    if (ld.TradeList[i].CloseQuantity > ld.TradeList[i].CloseBalance + item2.Balance)
                                        ld.TradeList[i].CloseBalance = ld.TradeList[i].CloseQuantity - item2.Balance;
                                    if (ld.TradeList[i].CloseQuantity == ld.TradeList[i].CloseBalance + item2.Balance && item2.Balance == 0)
                                        ld.TradeList[i].CloseBalance = ld.TradeList[i].CloseQuantity;
                                }
                            }
                    }
                    #endregion

                    //если в течении 10 секунд заявка не появилась в системе удалить ее, или ее сняли в ручном формате и не было исполнения, или удаляетс из списка если заявка не определена и уже ее смотрят в другом дне. На закрытие позиции
                    if ((ld.TradeList[i].CloseDate.TimeOfDay + new TimeSpan(0, 0, 15) <= DateTime.Now.TimeOfDay && ld.TradeList[i].CloseStatusOrder == Cfg.Unknown)
                        || (ld.TradeList[i].CloseDate.Date != DateTime.Now.Date && (ld.TradeList[i].CloseStatusOrder == Cfg.Unknown)))
                    {
                        ld.TradeList.Remove(ld.TradeList[i]);
                        if (i > 0)
                            i--;
                        if (i == 0)
                            break;
                    }

                    //если при переходе в другой день, заявки на закрытие остались активными, то сбросить их в статус null
                    if (ld.TradeList[i].CloseDate.Date != DateTime.Now.Date && ld.TradeList[i].CloseStatusOrder == Cfg.Active)
                        ld.TradeList[i].CloseStatusOrder = null;

                    //если в течении 10 секунд заявка не появилась в системе удалить ее, или ее сняли в ручном формате и не было исполнения, или удаляетс из списка если заявка не определена и уже ее смотрят в другом дне
                    if ((ld.TradeList[i].OpenDate.TimeOfDay + new TimeSpan(0, 0, 15) <= DateTime.Now.TimeOfDay && ld.TradeList[i].OpenStatusOrder == Cfg.Unknown)
                        || (ld.TradeList[i].OpenStatusOrder == Cfg.Cancel && ld.TradeList[i].OpenBalance == 0)
                        || (ld.TradeList[i].OpenDate.Date != DateTime.Now.Date && (ld.TradeList[i].OpenStatusOrder == Cfg.Unknown || ld.TradeList[i].OpenStatusOrder == Cfg.Active))
                        )
                    {
                        if (ld.TradeList[i].OpenBalance == 0)
                        {
                            ld.TradeList.Remove(ld.TradeList[i]);
                            if (i > 0)
                                i--;
                            if (i == 0)
                                break;
                        }
                        else
                        {
                            ld.TradeList[i].OpenStatusOrder = null;
                        }
                    }

                    if (ld.TradeList[i].OpenStatusOrder == Cfg.Cancel && ld.TradeList[i].OpenBalance != 0)
                    {
                        ld.TradeList[i].OpenStatusOrder = null;
                    }

                    //Заявка на открытие и закрытие исполнились полностью
                    if (ld.TradeList[i].CloseStatusOrder == Cfg.Performed && ld.TradeList[i].OpenQuantity == ld.TradeList[i].OpenBalance &&
                        ld.TradeList[i].CloseStatusOrder == Cfg.Performed && ld.TradeList[i].CloseQuantity == ld.TradeList[i].CloseBalance &&
                        (ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.Cancel || ld.TradeList[i].StopLimitCloseStatusOrder == null) &&
                        (ld.TradeList[i].OrderFromStopLimitCloseStatusOrder == Cfg.Cancel || ld.TradeList[i].OrderFromStopLimitCloseStatusOrder == null)
                        )
                    {
                        ld.TradeList.Remove(ld.TradeList[i]);
                        if (i > 0)
                            i--;
                        if (i == 0)
                            break;
                    }


                }
            }
            catch
            { }
        }

        /// <summary>
        /// блок проверки стоп-заявок статуса и баланса
        /// </summary>
        /// <param name="ld"></param>
        public void GetStatusAndBalanceStopLimit(GechikRobotItem ld)
        {
            try
            {
                var orderMassiv = data.GetOrderListAllforInstrunemts(ld.Account, ld.ClientCode, ld.Instrument);
                var StopLimitMassiv = data.GetStopOrderListAllforInstrunemts(ld.Account, ld.ClientCode, ld.Instrument);

                //Проверка исполнения заявки типа связанная заявка
                for (int i = 0; i < ld.TradeList.Count; i++)
                {
                    if (ld.TradeList.Count == 0)
                        break;

                    #region стоп лимит
                    foreach (var item2 in StopLimitMassiv)
                    {
                        //проверка статусов на изменение заявок на открытие пока балансе не равен выставленному числу
                        if (item2.Transactionid == ld.TradeList[i].StopLimitCloseID && ld.TradeList[i].StopLimitCloseStatusOrder != Cfg.Cancel && ld.TradeList[i].StopLimitCloseStatusOrder != Cfg.Performed)
                        {
                            ld.TradeList[i].StopLimitCloseStatusOrder = item2.Status;
                        }
                        //Проверка на изменение статуса стоп-заявки
                        if (item2.Transactionid == ld.TradeList[i].StopLimitCloseID)
                        {
                            if (ld.TradeList[i].StopLimitCloseStatusOrder != Cfg.Unknown)
                                ld.TradeList[i].StopLimitCloseStatusOrder = item2.Status;
                            ld.TradeList[i].StopLimitCloseNumberLinkidOrder = item2.Linkedorderno;
                            //если стоп-заявка отвергнута системой выставляем еще раз
                            //if (ld.TradeList[i].StopLimitCloseResult == cfg.REMOVE_FORM_TS)
                            //    ld.TradeList[i].StopLimitCloseStatusOrder = null;
                            //определяем номер заявки выставленной в систему при активации стоп-заявки
                            if (ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.AddToTs || ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.AddToTs)
                                ld.TradeList[i].StopLimitCloseNumberLinkidOrder = item2.Linkedorderno;
                        }
                    }

                    //Проверка на соответстивие ценам
                    if (ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.Active)
                        if (ld.TradeList[i].StopLimitClosePrice != GetStopPrice(ld))
                        {
                            method(
                                string.Format("Снятие стоп-заявки, цена стоп-заявки не верная"));
                            var sdfsdf = mainWindow.OConn.SendCommand(
                                 data.TransaqCommand.CancelStopOrder(ld.TradeList[0].StopLimitCloseID));
                        }

                    //если в течении 10 секунд стоп-заявка не появилась в системе удалить ее, или ее сняли в ручном формате и не было исполнения, или удаляетс из списка если заявка не определена и уже ее смотрят в другом дне. На закрытие позиции
                    if ((ld.TradeList[i].StopLimitCloseDate.TimeOfDay + new TimeSpan(0, 0, 10) <= DateTime.Now.TimeOfDay && ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.Unknown)
                        || (ld.TradeList[i].StopLimitCloseDate.Date != DateTime.Now.Date && (ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.Unknown)))
                    {
                        // ld.TradeList[i].StopLimitCloseStatusOrder = null;
                    }
                    #endregion

                    //перевыставляемся если стоп-заявка снята брокером
                    if (ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.BrokerCancel)
                    {
                        ld.TradeList[i].StopLimitCloseStatusOrder = null;
                    }

                    //провереям заявки на выставление
                    if (ld.TradeList[i].StopLimitCloseNumberLinkidOrder != 0 && ld.TradeList[i].StopLimitCloseStatusOrder != Cfg.Unknown)
                    {
                        foreach (var item2 in orderMassiv)
                        {
                            //проверка статусов на изменение заявок на закрытие позиции
                            if (ld.TradeList[i].StopLimitCloseID == item2.Transactionid && ld.TradeList[i].OrderFromStopLimitCloseStatusOrder == null)
                            {
                                ld.TradeList[i].OrderFromStopLimitCloseStatusOrder = item2.Status;
                                ld.TradeList[i].OrderFromStopLimitCloseNumberOrder = item2.Orderno;
                                ld.TradeList[i].OrderFromStopLimitCloseID = item2.Transactionid;
                            }

                            if (ld.TradeList[i].OrderFromStopLimitCloseStatusOrder != null && ld.TradeList[i].OrderFromStopLimitCloseID == item2.Transactionid
                                && ld.TradeList[i].StopLimitCloseNumberLinkidOrder == 0)
                                ld.TradeList[i].OrderFromStopLimitCloseStatusOrder = item2.Status;


                        }
                    }
                    //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Вот здесь необходимо прописать снятие заявок и стоп-заявок

                    //обнуление текущей позиции трейдлиста, при снятии стоп-заявки и заявки, обычно при переходе через клиринг или на другой день происходт
                    if (ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.Performed || ld.TradeList[i].CloseStatusOrder == Cfg.Performed)
                    {
                        if (ld.TradeList[i].StopLimitCloseStatusOrder == Cfg.Active)
                            mainWindow.OConn.SendCommand(data.TransaqCommand.CancelStopOrder(ld.TradeList[0].StopLimitCloseID));
                        if (ld.TradeList[i].OrderFromStopLimitCloseStatusOrder == Cfg.Active)
                            mainWindow.OConn.SendCommand(data.TransaqCommand.CancelStopOrder(ld.TradeList[0].OrderFromStopLimitCloseID));
                        if (ld.TradeList[i].CloseStatusOrder == Cfg.Active)
                            mainWindow.OConn.SendCommand(data.TransaqCommand.CancelStopOrder(ld.TradeList[0].CloseID));

                        if (ld.TradeList[i].StopLimitCloseStatusOrder != Cfg.Active && ld.TradeList[i].OrderFromStopLimitCloseStatusOrder != Cfg.Active && ld.TradeList[i].CloseStatusOrder != Cfg.Active)
                        {
                            if (ld.TradeList[i].CloseStatusOrder == Cfg.Performed)
                                ld.CurrentAttempt = ld.AttemptAmount;

                            ld.BreakevenFlag = false;
                            ld.TradeList.Remove(ld.TradeList[i]);
                            if (i > 0)
                                i--;
                            if (i == 0)
                                break;
                        }
                    }
                }
            }
            catch
            { }
        }

        ///// <summary>
        ///// Очистка листа. Если заявка на октрытие не исполнилась по заданным уловиям (отклонение цены от уровня больше заданного, время неисполнения больше заданного)
        ///// </summary>
        ///// <param name="ld"></param>
        //private void KillOpenOrderforCondidtion(LevelItem ld)
        //{
        //    //
        //    for (int i = 0; i < ld.TradeList.Count; i++)
        //    {
        //        if (ld.SettingOrderOpenClose.KillOrderOpen != cfg.UNKNOWN && ld.TradeList[i].OpenStatusOrder != cfg.UNKNOWN && ld.TradeList[i].OpenBalance == 0)
        //        {
        //            if (ld.SettingOrderOpenClose.KillOrderOpen == cfg.KillofTime || ld.SettingOrderOpenClose.KillOrderOpen == cfg.KillOfTimeOrDistance)
        //                if (ld.TradeList[i].OpenDate.TimeOfDay + TimeConvertor(ld.SettingOrderOpenClose.TimeWiatOpenPoz) <= DateTime.Now.TimeOfDay)
        //                {
        //                    mainWindow.Terminals.CancelOrder(ld.TradeList[i].OpenNumberOrder, ld.Instrument, Classcode, ld.Account, ld.ClientCode);
        //                    ld.TradeList.Remove(ld.TradeList[i]);
        //                    if (i > 0)
        //                        i--;
        //                    if (i == 0)
        //                        break;
        //                }

        //            if (ld.SettingOrderOpenClose.KillOrderOpen == cfg.KillOfDictance || ld.SettingOrderOpenClose.KillOrderOpen == cfg.KillOfTimeOrDistance)
        //            {
        //                if (ld.Operation == cfg.BUY && ld.trendItem.HorizontalLevel + ld.Excess + ld.SettingOrderOpenClose.SpredForKillOrderOpen <= TTP_Last)
        //                {
        //                    mainWindow.Terminals.CancelOrder(ld.TradeList[i].OpenNumberOrder, ld.Instrument, Classcode, ld.Account, ld.ClientCode);
        //                    ld.TradeList.Remove(ld.TradeList[i]);
        //                    if (i > 0)
        //                        i--;
        //                    if (i == 0)
        //                        break;
        //                }
        //                if (ld.Operation == cfg.SELL && ld.trendItem.HorizontalLevel - ld.Excess - ld.SettingOrderOpenClose.SpredForKillOrderOpen >= TTP_Last)
        //                {
        //                    mainWindow.Terminals.CancelOrder(ld.TradeList[i].OpenNumberOrder, ld.Instrument, Classcode, ld.Account, ld.ClientCode);
        //                    ld.TradeList.Remove(ld.TradeList[i]);
        //                    if (i > 0)
        //                        i--;
        //                    if (i == 0)
        //                        break;
        //                }

        //            }
        //        }
        //    }
        //}
    }
}
